![]() |
![]() |
|
Nicht immer kann ein Zustand eindeutig als wahr oder falsch angesehen werden. Das beste Beispiel dafür ist die linke Schaltfläche für fette Schrift in Abbildung 18.10. Ist der markierte Text sowohl fett als auch »normal«, gibt es einen dritten Zustand. Für solche Fälle dient die Eigenschaft CheckState, die Checked, Unchecked oder Indeterminate annehmen kann. Indeterminate beschreibt hierbei den nicht eindeutig definierbaren Zustand. Und was ist, wenn sich drei Symbolleistenschaltflächen in einer Gruppe befinden, wobei sich die Schaltflächen wie Radiobuttons verhalten sollen, also zu jedem Zeitpunkt nur einer ausgewählt sein darf? Was im ersten Moment vielleicht recht schwierig aussieht, ist recht einfach zu lösen. Angenommen, die drei Symbolleistenschaltflächen heißen tsButton1, tsButton2 und tsButton3, so könnte die Lösung wie im folgenden Programmcode zu sehen sein:
Dieser Code spiegelt das Verhalten der Schaltflächen zur Textausrichtung unter MS Word wider. Klicken Sie hier auf eine aktuell Symbolleistenschaltfläche, wird die angeklickte deaktiviert und die in der Reihenfolge nächste ausgewählt. Weniger aufwändig wäre der Weg, wenn das Visual Studio Control-Array direkt unterstützen würde. Dann könnte mit dem Index der Elemente jongliert werden. Leider bietet aber Visual Studio diese Unterstützung nicht an, so dass dieser Lösungsweg ausscheidet. Sie könnten selbstverständlich auch mittels Code ein Array von ToolStripButton-Objekten erzeugen und der Auflistung des ToolStrip-Controls hinzufügen. Nur ist dieser Aufwand größer als der, den wir oben für die drei Schaltflächen betreiben mussten. 18.5.2 Drop-down-Buttons in Symbolleisten
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| toolStripComboBox1.SelectedIndex = 0; |
Dazu bietet sich der Konstruktor der Form (nach InitializeComponent) oder das Load-Ereignis der Form an.
Hat der Benutzer sich für ein Element aus der Liste entschieden, können Sie dieses unter anderem durch Auswerten der Eigenschaft Text erhalten. Für die Auswertung ist aber das Ereignis Click denkbar ungeeignet, da es ausgelöst wird, sobald auf das Kombinationslistenfeld geklickt wird. In diesem Fall sollten Sie den erforderlichen Programmcode im Ereignishandler von SelectedIndexChanged implementieren.
Einfache Textinformationen können Sie in einer Symbolleiste bereitstellen, wenn Sie sich für das angebotene ToolStripLabel entscheiden. Möchten Sie dem Anwender jedoch die Möglichkeit geben, selbst eine Zeichenfolge einzutragen, ist ein ToolStripTextBox-Element gefragt. Auch wenn Ihnen die Eigenschaft Lines suggeriert, es handle sich um eine Textbox, die mehrere Zeilen zulässt, tatsächlich wird nur eine angezeigt, die durch die Eigenschaft Text beschrieben wird.
Symbolleistentextboxen unterstützen die Autovervollständigung und weitere Eigenschaften, die auch eine herkömmliche TextBox hat. Dieser hatten wir uns in Kapitel 16 gewidmet und werden deshalb nicht noch einmal das Gesagte wiederholen. Im Zweifelsfall lesen Sie dort bitte noch einmal nach.
Zu guter Letzt können Sie dem Anwender zur Laufzeit auch einen Fortschrittsbalken anbieten, der über den aktuellen Stand einer länger andauernden Operation informiert. Fortschrittsbalken in einer Symbolleiste sind vom Typ ToolStripProgressBar. Die Fähigkeiten sind praktisch identisch denen eines Objekts vom Typ ProgressBar, dem wir uns im nächsten Kapitel zuwenden.
Eine Symbolleiste bietet eine Reihe integrierter Steuerelemente an. Viele Steuerelemente reagieren auf das Click-Ereignis, zum Beispiel die übliche Schaltfläche, aber auch ein Label oder eine Drop-down-Schaltfläche. Sie können jedes Ereignis separat programmieren, was gegebenenfalls zu einer sehr großen Zahl von Ereignishandlern führt.
Eine andere, übersichtlichere Lösung wäre ein gemeinsamer Ereignishandler, für alle Click-Ereignisse einer Symbolleiste. Hier hilft uns das ToolStrip-Objekt weiter, das dazu ein passendes Ereignis in ItemClicked bereitstellt. Registrieren Sie bei diesem Event einen Ereignishandler, wird dieser ausgelöst, wenn in der Symbolleiste ein Element angeklickt wird.
| public event ToolStripItemClickedEventHandler ItemClicked; |
Dem Ereignishandler kommt dann die Aufgabe zu festzustellen, auf welche Schaltfläche der Anwender geklickt hat. Der zweite Parameter des Handlers vom Typ ToolStripItemClickedEventArgs stellt zu diesem Zweck eine Eigenschaft mit der passenden Information zur Verfügung: Es handelt sich um dessen Eigenschaft ClickedItem.
| public ToolStripItem ClickedItem {get;} |
Da der Ereignishandler alle Click-Ereignisse einer Symbolleiste behandelt, müssen wir über die Eigenschaft ClickedItem zuerst herausfinden, welcher Komponente das ausgelöste Ereignis zugeordnet werden muss, um dann entsprechend zu reagieren. Eine Möglichkeit wäre es, den Index der geklickten Schaltfläche in der Auflistung festzustellen und die entsprechende Programmreaktion in Abhängigkeit vom Index zu setzen.
| private void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e) { |
| switch (toolStrip1.Items.IndexOf(e.ClickedItem)) { |
| case 0: |
| MessageBox.Show("Erste Schaltfläche angeklickt."); |
| break; |
| case 1: |
| MessageBox.Show("Zweite Schaltfläche angeklickt."); |
| break; |
| ... |
| } |
| } |
Diese Lösung hat aber einen Nachteil, wenn sich die Indizes der Schaltflächen zur Laufzeit ändern. Das könnte beispielsweise der Fall sein, wenn Sie dem Anwender einräumen, die Struktur der Symbolleiste zur Laufzeit zu ändern. Es stimmt dann die feste Zuordnung zwischen Schaltfläche und Index nicht mehr, die bei unserem Codefragment eine unabdingbare Voraussetzung ist.
Ein flexibler Lösungsansatz geht daher einen anderen Weg, um die angeklickte Symbolleistenschaltfläche zu identifizieren. Dieser Ansatz nutzt die Eigenschaft Tag des Symbolleistenelements. In der Tag-Eigenschaft, über die auch andere Steuerelemente verfügen, können beliebige Informationen gespeichert werden, die der Entwickler im Bedarfsfall nach eigenen Vorstellungen nutzen kann.
| public object Tag {get; set;} |
In unserem konkreten Fall könnten wir der Tag-Eigenschaft jeder Symbolleistenschaltfläche eine in der Auflistung eindeutige Zeichenfolge übergeben, die wir in einer switch-Anweisung identifizieren.
| private void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e) { |
| switch (e.ClickedItem.Tag.ToString()) { |
| case "Open": |
| MessageBox.Show("Erste Schaltfläche angeklickt."); |
| break; |
| case "New": |
| MessageBox.Show("Zweite Schaltfläche angeklickt."); |
| break; |
| ... |
| } |
| } |
Das folgende Beispiel DropDownButtons enthält in der Symbolleiste sowohl Umschaltflächen als auch eine Drop-down-Schaltfläche mit dem Bezeichner colorButton. Damit kann der Text einer formfüllenden Textbox entweder fett, kursiv, unterstrichen oder in einer anderen Schriftfarbe dargestellt werden. Eine DropDownButton-Symbolleistenschaltfläche zeigt dabei immer die aktuell gewählte Schriftfarbe als quadratisches Symbol an und passt sich gegebenenfalls auch Änderungen an.
| // -------------------------------------------------------------- |
| // Beispiel: ...\Kapitel 18\DropDownButtons |
| // -------------------------------------------------------------- |
| public partial class Form1 : Form { |
| FontStyle fontstyle = FontStyle.Regular; |
| ToolStripMenuItem[] menuArr; |
| public Form1() { |
| InitializeComponent() |
| // DropDown-Menüelemente in ein Array schreiben |
| menuArr = new ToolStripMenuItem[] { menuRot, menuGelb, menuBlau }; |
| // Initialisierung der Anzeige |
| this.menuRot_Click(menuRot, null); |
| textBox.SelectionStart = textBox.Text.Length; |
| } |
| // Festlegen des Schriftstils |
| private void toolStrip1_ItemClicked(object sender, |
| ToolStripItemClickedEventArgs e) { |
| if (e.ClickedItem.Tag != null) { |
| switch ((string)(e.ClickedItem.Tag)) { |
| case "Bold": |
| fontstyle ^= FontStyle.Bold; |
| break; |
| case "Italic": |
| fontstyle ^= FontStyle.Italic; |
| break; |
| case "Underline": |
| fontstyle ^= FontStyle.Underline; |
| break; |
| } |
| textBox.Font = new Font(textBox.Font, fontstyle); |
| } |
| } |
| private void SetFontColor(ToolStripItem button, Color color) { |
| Bitmap bmp = new Bitmap(16, 16); |
| Graphics graph = Graphics.FromImage(bmp); |
| // füllt Bitmap mit der neuen Farbe |
| graph.Clear(color); |
| // Bitmap der Eigenschaft Image zuweisen |
| tlbColorDropDown.Image = bmp; |
| // Setzen der Textfarbe in der Textbox |
| textBox.ForeColor = color; |
| } |
| private void menuRot_Click(object sender, EventArgs e) { |
| SetFontColor(this.toolStrip1.Items["menuRot"], Color.Red); |
| this.SetChecked(sender); |
| } |
| private void menuBlau_Click(object sender, EventArgs e) { |
| SetFontColor(this.toolStrip1.Items["menuBlau"], Color.Blue); |
| this.SetChecked(sender); |
| } |
| private void menuGelb_Click(object sender, EventArgs e) { |
| SetFontColor(this.toolStrip1.Items["menuGelb"], Color.Yellow); |
| this.SetChecked(sender); |
| } |
| // Setzen des Auswahlhäkchens |
| private void SetChecked(object sender) { |
| if (menuArr != null) { |
| foreach (ToolStripMenuItem menu in menuArr) |
| menu.Checked = false; |
| ((ToolStripMenuItem)sender).Checked = true; |
| } |
| } |
| } |
Betrachten wir zuerst die drei Symbolleistenschaltflächen, mit denen der Schriftstil Fett, Kursiv und Unterstrichen eingestellt werden kann. Es bietet sich an, im Ereignishandler von ItemClicked zu prüfen, ob eine Schaltfläche in der Symbolleiste angeklickt worden ist, die für die Umschaltung einer der genannten Schriftstile verantwortlich ist. Im switch-Satetment wird dazu die Tag-Eigenschaft ausgewertet.
Da durch den Typ FontStyle eine Bitkombination beschrieben wird, müssen wir nur das entsprechende Bit, das Auskunft über fette, kursive oder unterstrichene Darstellung einer Schrift gibt, bei jedem Klick auf die zugeordnete Schaltfläche invertieren. Dazu bietet sich der »^«-Operator an. Bei der Schaltfläche zum Umstellen auf fette bzw. nicht fette Darstellung sieht die Anweisung dazu wie folgt aus:
| fontstyle ^= FontStyle.Bold; |
Die Menüelemente menuRot, menuGelb und menuBlau der Drop-down-Schaltfläche werden im Array menuArr vom Typ ToolStripMenuItem verwaltet, das auf Klassenebene deklariert und im Konstruktor initialisiert wird. Wir erleichtern uns damit den Zugriff auf die Menüelemente, wenn das Auswahlhäkchen gesetzt wird, um die gewählte Schriftfarbe auch optisch hervorzuheben. Diese Aufgabe übernimmt die Methode SetChecked.
Um dem Anwender die aktuelle Farbwahl durch ein farblich angepasstes Bildchen in der Symbolleiste anzuzeigen, müssen wir in wenig in die Trickkiste greifen.
Jeder Klick auf eines der drei Menüelemente löst ein Ereignis aus. Im zugeordneten Ereignishandler wird die Methode SetFontColor aufgerufen und dabei die Referenz auf die Symbolleistenschaltfläche und die gewählte Farbe übergeben, z.B.:
| SetFontColor(this.toolStrip1.Items["menuRot"], Color.Red); |
Jedes Bildchen der Symbolleiste basiert auf einer Bitmap. In SetFontColor wird daher zuerst mit
| Bitmap bmp = new Bitmap(16, 16); |
ein Objekt dieses Typs in der Größe 16 x 16 Pixel neu erzeugt. Um grafische Operationen ausführen zu können, benötigen wir die Referenz auf das Graphics-Objekt dieser Bitmap:
| Graphics graph = Graphics.FromImage(bmp); |
Danach legen wir die Hintergrundfarbe mit
| graph.Clear(color); |
fest. Das neue Bitmap ist damit fertig. Wir übergeben nur noch dessen Referenz der Eigenschaft Image des ToolStripDropDownButton-Objekts und haben das gesetzte Ziel erreicht:
| tlbColorDropDown.Image = bmp; |
| << zurück |
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
Copyright © Galileo Press 2006
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.